// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/stirling/source_connectors/dynamic_tracer/dynamic_tracing/ir/sharedpb/shared.proto

package sharedpb

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type Language int32

const (
	LANG_UNKNOWN Language = 0
	C            Language = 1
	CPP          Language = 2
	GOLANG       Language = 3
)

var Language_name = map[int32]string{
	0: "LANG_UNKNOWN",
	1: "C",
	2: "CPP",
	3: "GOLANG",
}

var Language_value = map[string]int32{
	"LANG_UNKNOWN": 0,
	"C":            1,
	"CPP":          2,
	"GOLANG":       3,
}

func (Language) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{0}
}

type BPFHelper int32

const (
	GOID            BPFHelper = 0
	TGID            BPFHelper = 1
	TGID_PID        BPFHelper = 2
	TGID_START_TIME BPFHelper = 3
	KTIME           BPFHelper = 4
)

var BPFHelper_name = map[int32]string{
	0: "GOID",
	1: "TGID",
	2: "TGID_PID",
	3: "TGID_START_TIME",
	4: "KTIME",
}

var BPFHelper_value = map[string]int32{
	"GOID":            0,
	"TGID":            1,
	"TGID_PID":        2,
	"TGID_START_TIME": 3,
	"KTIME":           4,
}

func (BPFHelper) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{1}
}

type ScalarType int32

const (
	UNKNOWN      ScalarType = 0
	BOOL         ScalarType = 100
	SHORT        ScalarType = 200
	USHORT       ScalarType = 201
	INT          ScalarType = 202
	UINT         ScalarType = 203
	LONG         ScalarType = 204
	ULONG        ScalarType = 205
	LONGLONG     ScalarType = 206
	ULONGLONG    ScalarType = 207
	INT8         ScalarType = 300
	INT16        ScalarType = 301
	INT32        ScalarType = 302
	INT64        ScalarType = 303
	UINT8        ScalarType = 304
	UINT16       ScalarType = 305
	UINT32       ScalarType = 306
	UINT64       ScalarType = 307
	CHAR         ScalarType = 400
	UCHAR        ScalarType = 401
	FLOAT        ScalarType = 500
	DOUBLE       ScalarType = 501
	VOID_POINTER ScalarType = 900
	STRING       ScalarType = 1000
	BYTE_ARRAY   ScalarType = 1001
	STRUCT_BLOB  ScalarType = 1100
)

var ScalarType_name = map[int32]string{
	0:    "UNKNOWN",
	100:  "BOOL",
	200:  "SHORT",
	201:  "USHORT",
	202:  "INT",
	203:  "UINT",
	204:  "LONG",
	205:  "ULONG",
	206:  "LONGLONG",
	207:  "ULONGLONG",
	300:  "INT8",
	301:  "INT16",
	302:  "INT32",
	303:  "INT64",
	304:  "UINT8",
	305:  "UINT16",
	306:  "UINT32",
	307:  "UINT64",
	400:  "CHAR",
	401:  "UCHAR",
	500:  "FLOAT",
	501:  "DOUBLE",
	900:  "VOID_POINTER",
	1000: "STRING",
	1001: "BYTE_ARRAY",
	1100: "STRUCT_BLOB",
}

var ScalarType_value = map[string]int32{
	"UNKNOWN":      0,
	"BOOL":         100,
	"SHORT":        200,
	"USHORT":       201,
	"INT":          202,
	"UINT":         203,
	"LONG":         204,
	"ULONG":        205,
	"LONGLONG":     206,
	"ULONGLONG":    207,
	"INT8":         300,
	"INT16":        301,
	"INT32":        302,
	"INT64":        303,
	"UINT8":        304,
	"UINT16":       305,
	"UINT32":       306,
	"UINT64":       307,
	"CHAR":         400,
	"UCHAR":        401,
	"FLOAT":        500,
	"DOUBLE":       501,
	"VOID_POINTER": 900,
	"STRING":       1000,
	"BYTE_ARRAY":   1001,
	"STRUCT_BLOB":  1100,
}

func (ScalarType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{2}
}

type Tracepoint_Type int32

const (
	LOGICAL Tracepoint_Type = 0
	ENTRY   Tracepoint_Type = 1
	RETURN  Tracepoint_Type = 2
)

var Tracepoint_Type_name = map[int32]string{
	0: "LOGICAL",
	1: "ENTRY",
	2: "RETURN",
}

var Tracepoint_Type_value = map[string]int32{
	"LOGICAL": 0,
	"ENTRY":   1,
	"RETURN":  2,
}

func (Tracepoint_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{0, 0}
}

type Condition_Op int32

const (
	NIL   Condition_Op = 0
	EQUAL Condition_Op = 1
)

var Condition_Op_name = map[int32]string{
	0: "NIL",
	1: "EQUAL",
}

var Condition_Op_value = map[string]int32{
	"NIL":   0,
	"EQUAL": 1,
}

func (Condition_Op) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{7, 0}
}

type Tracepoint struct {
	Function *Tracepoint_Function `protobuf:"bytes,3,opt,name=function,proto3" json:"function,omitempty"`
	Symbol   string               `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	Type     Tracepoint_Type      `protobuf:"varint,2,opt,name=type,proto3,enum=px.stirling.dynamic_tracing.ir.shared.Tracepoint_Type" json:"type,omitempty"`
}

func (m *Tracepoint) Reset()      { *m = Tracepoint{} }
func (*Tracepoint) ProtoMessage() {}
func (*Tracepoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{0}
}
func (m *Tracepoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Tracepoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Tracepoint.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Tracepoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Tracepoint.Merge(m, src)
}
func (m *Tracepoint) XXX_Size() int {
	return m.Size()
}
func (m *Tracepoint) XXX_DiscardUnknown() {
	xxx_messageInfo_Tracepoint.DiscardUnknown(m)
}

var xxx_messageInfo_Tracepoint proto.InternalMessageInfo

func (m *Tracepoint) GetFunction() *Tracepoint_Function {
	if m != nil {
		return m.Function
	}
	return nil
}

func (m *Tracepoint) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *Tracepoint) GetType() Tracepoint_Type {
	if m != nil {
		return m.Type
	}
	return LOGICAL
}

type Tracepoint_Function struct {
	Name       string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ParamTypes []string `protobuf:"bytes,2,rep,name=param_types,json=paramTypes,proto3" json:"param_types,omitempty"`
}

func (m *Tracepoint_Function) Reset()      { *m = Tracepoint_Function{} }
func (*Tracepoint_Function) ProtoMessage() {}
func (*Tracepoint_Function) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{0, 0}
}
func (m *Tracepoint_Function) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Tracepoint_Function) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Tracepoint_Function.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Tracepoint_Function) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Tracepoint_Function.Merge(m, src)
}
func (m *Tracepoint_Function) XXX_Size() int {
	return m.Size()
}
func (m *Tracepoint_Function) XXX_DiscardUnknown() {
	xxx_messageInfo_Tracepoint_Function.DiscardUnknown(m)
}

var xxx_messageInfo_Tracepoint_Function proto.InternalMessageInfo

func (m *Tracepoint_Function) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Tracepoint_Function) GetParamTypes() []string {
	if m != nil {
		return m.ParamTypes
	}
	return nil
}

type UPID struct {
	Asid uint32 `protobuf:"varint,1,opt,name=asid,proto3" json:"asid,omitempty"`
	Pid  uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
	TsNs uint64 `protobuf:"varint,3,opt,name=ts_ns,json=tsNs,proto3" json:"ts_ns,omitempty"`
}

func (m *UPID) Reset()      { *m = UPID{} }
func (*UPID) ProtoMessage() {}
func (*UPID) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{1}
}
func (m *UPID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UPID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UPID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UPID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UPID.Merge(m, src)
}
func (m *UPID) XXX_Size() int {
	return m.Size()
}
func (m *UPID) XXX_DiscardUnknown() {
	xxx_messageInfo_UPID.DiscardUnknown(m)
}

var xxx_messageInfo_UPID proto.InternalMessageInfo

func (m *UPID) GetAsid() uint32 {
	if m != nil {
		return m.Asid
	}
	return 0
}

func (m *UPID) GetPid() uint32 {
	if m != nil {
		return m.Pid
	}
	return 0
}

func (m *UPID) GetTsNs() uint64 {
	if m != nil {
		return m.TsNs
	}
	return 0
}

type BinaryPathList struct {
	Paths []string `protobuf:"bytes,1,rep,name=paths,proto3" json:"paths,omitempty"`
}

func (m *BinaryPathList) Reset()      { *m = BinaryPathList{} }
func (*BinaryPathList) ProtoMessage() {}
func (*BinaryPathList) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{2}
}
func (m *BinaryPathList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BinaryPathList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BinaryPathList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BinaryPathList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BinaryPathList.Merge(m, src)
}
func (m *BinaryPathList) XXX_Size() int {
	return m.Size()
}
func (m *BinaryPathList) XXX_DiscardUnknown() {
	xxx_messageInfo_BinaryPathList.DiscardUnknown(m)
}

var xxx_messageInfo_BinaryPathList proto.InternalMessageInfo

func (m *BinaryPathList) GetPaths() []string {
	if m != nil {
		return m.Paths
	}
	return nil
}

type UPIDList struct {
	Upids []*UPID `protobuf:"bytes,1,rep,name=upids,proto3" json:"upids,omitempty"`
}

func (m *UPIDList) Reset()      { *m = UPIDList{} }
func (*UPIDList) ProtoMessage() {}
func (*UPIDList) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{3}
}
func (m *UPIDList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UPIDList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UPIDList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UPIDList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UPIDList.Merge(m, src)
}
func (m *UPIDList) XXX_Size() int {
	return m.Size()
}
func (m *UPIDList) XXX_DiscardUnknown() {
	xxx_messageInfo_UPIDList.DiscardUnknown(m)
}

var xxx_messageInfo_UPIDList proto.InternalMessageInfo

func (m *UPIDList) GetUpids() []*UPID {
	if m != nil {
		return m.Upids
	}
	return nil
}

type DeploymentSpec struct {
	// Types that are valid to be assigned to TargetOneof:
	//
	//	*DeploymentSpec_PathList
	//	*DeploymentSpec_UpidList
	//	*DeploymentSpec_SharedObject_
	//	*DeploymentSpec_PodProcess_
	TargetOneof isDeploymentSpec_TargetOneof `protobuf_oneof:"target_oneof"`
}

func (m *DeploymentSpec) Reset()      { *m = DeploymentSpec{} }
func (*DeploymentSpec) ProtoMessage() {}
func (*DeploymentSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{4}
}
func (m *DeploymentSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec.Merge(m, src)
}
func (m *DeploymentSpec) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec proto.InternalMessageInfo

type isDeploymentSpec_TargetOneof interface {
	isDeploymentSpec_TargetOneof()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type DeploymentSpec_PathList struct {
	PathList *BinaryPathList `protobuf:"bytes,1,opt,name=path_list,json=pathList,proto3,oneof" json:"path_list,omitempty"`
}
type DeploymentSpec_UpidList struct {
	UpidList *UPIDList `protobuf:"bytes,3,opt,name=upid_list,json=upidList,proto3,oneof" json:"upid_list,omitempty"`
}
type DeploymentSpec_SharedObject_ struct {
	SharedObject *DeploymentSpec_SharedObject `protobuf:"bytes,8,opt,name=shared_object,json=sharedObject,proto3,oneof" json:"shared_object,omitempty"`
}
type DeploymentSpec_PodProcess_ struct {
	PodProcess *DeploymentSpec_PodProcess `protobuf:"bytes,10,opt,name=pod_process,json=podProcess,proto3,oneof" json:"pod_process,omitempty"`
}

func (*DeploymentSpec_PathList) isDeploymentSpec_TargetOneof()      {}
func (*DeploymentSpec_UpidList) isDeploymentSpec_TargetOneof()      {}
func (*DeploymentSpec_SharedObject_) isDeploymentSpec_TargetOneof() {}
func (*DeploymentSpec_PodProcess_) isDeploymentSpec_TargetOneof()   {}

func (m *DeploymentSpec) GetTargetOneof() isDeploymentSpec_TargetOneof {
	if m != nil {
		return m.TargetOneof
	}
	return nil
}

func (m *DeploymentSpec) GetPathList() *BinaryPathList {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_PathList); ok {
		return x.PathList
	}
	return nil
}

func (m *DeploymentSpec) GetUpidList() *UPIDList {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_UpidList); ok {
		return x.UpidList
	}
	return nil
}

func (m *DeploymentSpec) GetSharedObject() *DeploymentSpec_SharedObject {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_SharedObject_); ok {
		return x.SharedObject
	}
	return nil
}

func (m *DeploymentSpec) GetPodProcess() *DeploymentSpec_PodProcess {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_PodProcess_); ok {
		return x.PodProcess
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*DeploymentSpec) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*DeploymentSpec_PathList)(nil),
		(*DeploymentSpec_UpidList)(nil),
		(*DeploymentSpec_SharedObject_)(nil),
		(*DeploymentSpec_PodProcess_)(nil),
	}
}

type DeploymentSpec_SharedObject struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Upid *UPID  `protobuf:"bytes,2,opt,name=upid,proto3" json:"upid,omitempty"`
}

func (m *DeploymentSpec_SharedObject) Reset()      { *m = DeploymentSpec_SharedObject{} }
func (*DeploymentSpec_SharedObject) ProtoMessage() {}
func (*DeploymentSpec_SharedObject) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{4, 0}
}
func (m *DeploymentSpec_SharedObject) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec_SharedObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec_SharedObject.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec_SharedObject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec_SharedObject.Merge(m, src)
}
func (m *DeploymentSpec_SharedObject) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec_SharedObject) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec_SharedObject.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec_SharedObject proto.InternalMessageInfo

func (m *DeploymentSpec_SharedObject) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DeploymentSpec_SharedObject) GetUpid() *UPID {
	if m != nil {
		return m.Upid
	}
	return nil
}

type DeploymentSpec_PodProcess struct {
	Pods      []string `protobuf:"bytes,1,rep,name=pods,proto3" json:"pods,omitempty"`
	Container string   `protobuf:"bytes,2,opt,name=container,proto3" json:"container,omitempty"`
	Process   string   `protobuf:"bytes,3,opt,name=process,proto3" json:"process,omitempty"`
}

func (m *DeploymentSpec_PodProcess) Reset()      { *m = DeploymentSpec_PodProcess{} }
func (*DeploymentSpec_PodProcess) ProtoMessage() {}
func (*DeploymentSpec_PodProcess) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{4, 1}
}
func (m *DeploymentSpec_PodProcess) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec_PodProcess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec_PodProcess.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec_PodProcess) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec_PodProcess.Merge(m, src)
}
func (m *DeploymentSpec_PodProcess) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec_PodProcess) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec_PodProcess.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec_PodProcess proto.InternalMessageInfo

func (m *DeploymentSpec_PodProcess) GetPods() []string {
	if m != nil {
		return m.Pods
	}
	return nil
}

func (m *DeploymentSpec_PodProcess) GetContainer() string {
	if m != nil {
		return m.Container
	}
	return ""
}

func (m *DeploymentSpec_PodProcess) GetProcess() string {
	if m != nil {
		return m.Process
	}
	return ""
}

type VariableType struct {
	// Types that are valid to be assigned to TypeOneof:
	//
	//	*VariableType_Scalar
	//	*VariableType_StructType
	TypeOneof isVariableType_TypeOneof `protobuf_oneof:"type_oneof"`
}

func (m *VariableType) Reset()      { *m = VariableType{} }
func (*VariableType) ProtoMessage() {}
func (*VariableType) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{5}
}
func (m *VariableType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VariableType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VariableType.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *VariableType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VariableType.Merge(m, src)
}
func (m *VariableType) XXX_Size() int {
	return m.Size()
}
func (m *VariableType) XXX_DiscardUnknown() {
	xxx_messageInfo_VariableType.DiscardUnknown(m)
}

var xxx_messageInfo_VariableType proto.InternalMessageInfo

type isVariableType_TypeOneof interface {
	isVariableType_TypeOneof()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type VariableType_Scalar struct {
	Scalar ScalarType `protobuf:"varint,2,opt,name=scalar,proto3,enum=px.stirling.dynamic_tracing.ir.shared.ScalarType,oneof" json:"scalar,omitempty"`
}
type VariableType_StructType struct {
	StructType string `protobuf:"bytes,3,opt,name=struct_type,json=structType,proto3,oneof" json:"struct_type,omitempty"`
}

func (*VariableType_Scalar) isVariableType_TypeOneof()     {}
func (*VariableType_StructType) isVariableType_TypeOneof() {}

func (m *VariableType) GetTypeOneof() isVariableType_TypeOneof {
	if m != nil {
		return m.TypeOneof
	}
	return nil
}

func (m *VariableType) GetScalar() ScalarType {
	if x, ok := m.GetTypeOneof().(*VariableType_Scalar); ok {
		return x.Scalar
	}
	return UNKNOWN
}

func (m *VariableType) GetStructType() string {
	if x, ok := m.GetTypeOneof().(*VariableType_StructType); ok {
		return x.StructType
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*VariableType) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*VariableType_Scalar)(nil),
		(*VariableType_StructType)(nil),
	}
}

type Map struct {
	Name      string        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	KeyType   *VariableType `protobuf:"bytes,2,opt,name=key_type,json=keyType,proto3" json:"key_type,omitempty"`
	ValueType *VariableType `protobuf:"bytes,3,opt,name=value_type,json=valueType,proto3" json:"value_type,omitempty"`
}

func (m *Map) Reset()      { *m = Map{} }
func (*Map) ProtoMessage() {}
func (*Map) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{6}
}
func (m *Map) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Map) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Map.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Map) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Map.Merge(m, src)
}
func (m *Map) XXX_Size() int {
	return m.Size()
}
func (m *Map) XXX_DiscardUnknown() {
	xxx_messageInfo_Map.DiscardUnknown(m)
}

var xxx_messageInfo_Map proto.InternalMessageInfo

func (m *Map) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Map) GetKeyType() *VariableType {
	if m != nil {
		return m.KeyType
	}
	return nil
}

func (m *Map) GetValueType() *VariableType {
	if m != nil {
		return m.ValueType
	}
	return nil
}

type Condition struct {
	Op   Condition_Op `protobuf:"varint,1,opt,name=op,proto3,enum=px.stirling.dynamic_tracing.ir.shared.Condition_Op" json:"op,omitempty"`
	Vars []string     `protobuf:"bytes,2,rep,name=vars,proto3" json:"vars,omitempty"`
}

func (m *Condition) Reset()      { *m = Condition{} }
func (*Condition) ProtoMessage() {}
func (*Condition) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{7}
}
func (m *Condition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Condition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Condition.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Condition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Condition.Merge(m, src)
}
func (m *Condition) XXX_Size() int {
	return m.Size()
}
func (m *Condition) XXX_DiscardUnknown() {
	xxx_messageInfo_Condition.DiscardUnknown(m)
}

var xxx_messageInfo_Condition proto.InternalMessageInfo

func (m *Condition) GetOp() Condition_Op {
	if m != nil {
		return m.Op
	}
	return NIL
}

func (m *Condition) GetVars() []string {
	if m != nil {
		return m.Vars
	}
	return nil
}

type Printk struct {
	// Types that are valid to be assigned to ContentOneof:
	//
	//	*Printk_Text
	//	*Printk_Scalar
	ContentOneof isPrintk_ContentOneof `protobuf_oneof:"content_oneof"`
}

func (m *Printk) Reset()      { *m = Printk{} }
func (*Printk) ProtoMessage() {}
func (*Printk) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{8}
}
func (m *Printk) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Printk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Printk.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Printk) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Printk.Merge(m, src)
}
func (m *Printk) XXX_Size() int {
	return m.Size()
}
func (m *Printk) XXX_DiscardUnknown() {
	xxx_messageInfo_Printk.DiscardUnknown(m)
}

var xxx_messageInfo_Printk proto.InternalMessageInfo

type isPrintk_ContentOneof interface {
	isPrintk_ContentOneof()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Printk_Text struct {
	Text string `protobuf:"bytes,1,opt,name=text,proto3,oneof" json:"text,omitempty"`
}
type Printk_Scalar struct {
	Scalar string `protobuf:"bytes,2,opt,name=scalar,proto3,oneof" json:"scalar,omitempty"`
}

func (*Printk_Text) isPrintk_ContentOneof()   {}
func (*Printk_Scalar) isPrintk_ContentOneof() {}

func (m *Printk) GetContentOneof() isPrintk_ContentOneof {
	if m != nil {
		return m.ContentOneof
	}
	return nil
}

func (m *Printk) GetText() string {
	if x, ok := m.GetContentOneof().(*Printk_Text); ok {
		return x.Text
	}
	return ""
}

func (m *Printk) GetScalar() string {
	if x, ok := m.GetContentOneof().(*Printk_Scalar); ok {
		return x.Scalar
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Printk) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Printk_Text)(nil),
		(*Printk_Scalar)(nil),
	}
}

type FunctionLatency struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *FunctionLatency) Reset()      { *m = FunctionLatency{} }
func (*FunctionLatency) ProtoMessage() {}
func (*FunctionLatency) Descriptor() ([]byte, []int) {
	return fileDescriptor_90e8d4eece86f82b, []int{9}
}
func (m *FunctionLatency) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FunctionLatency) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FunctionLatency.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FunctionLatency) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FunctionLatency.Merge(m, src)
}
func (m *FunctionLatency) XXX_Size() int {
	return m.Size()
}
func (m *FunctionLatency) XXX_DiscardUnknown() {
	xxx_messageInfo_FunctionLatency.DiscardUnknown(m)
}

var xxx_messageInfo_FunctionLatency proto.InternalMessageInfo

func (m *FunctionLatency) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func init() {
	proto.RegisterEnum("px.stirling.dynamic_tracing.ir.shared.Language", Language_name, Language_value)
	proto.RegisterEnum("px.stirling.dynamic_tracing.ir.shared.BPFHelper", BPFHelper_name, BPFHelper_value)
	proto.RegisterEnum("px.stirling.dynamic_tracing.ir.shared.ScalarType", ScalarType_name, ScalarType_value)
	proto.RegisterEnum("px.stirling.dynamic_tracing.ir.shared.Tracepoint_Type", Tracepoint_Type_name, Tracepoint_Type_value)
	proto.RegisterEnum("px.stirling.dynamic_tracing.ir.shared.Condition_Op", Condition_Op_name, Condition_Op_value)
	proto.RegisterType((*Tracepoint)(nil), "px.stirling.dynamic_tracing.ir.shared.Tracepoint")
	proto.RegisterType((*Tracepoint_Function)(nil), "px.stirling.dynamic_tracing.ir.shared.Tracepoint.Function")
	proto.RegisterType((*UPID)(nil), "px.stirling.dynamic_tracing.ir.shared.UPID")
	proto.RegisterType((*BinaryPathList)(nil), "px.stirling.dynamic_tracing.ir.shared.BinaryPathList")
	proto.RegisterType((*UPIDList)(nil), "px.stirling.dynamic_tracing.ir.shared.UPIDList")
	proto.RegisterType((*DeploymentSpec)(nil), "px.stirling.dynamic_tracing.ir.shared.DeploymentSpec")
	proto.RegisterType((*DeploymentSpec_SharedObject)(nil), "px.stirling.dynamic_tracing.ir.shared.DeploymentSpec.SharedObject")
	proto.RegisterType((*DeploymentSpec_PodProcess)(nil), "px.stirling.dynamic_tracing.ir.shared.DeploymentSpec.PodProcess")
	proto.RegisterType((*VariableType)(nil), "px.stirling.dynamic_tracing.ir.shared.VariableType")
	proto.RegisterType((*Map)(nil), "px.stirling.dynamic_tracing.ir.shared.Map")
	proto.RegisterType((*Condition)(nil), "px.stirling.dynamic_tracing.ir.shared.Condition")
	proto.RegisterType((*Printk)(nil), "px.stirling.dynamic_tracing.ir.shared.Printk")
	proto.RegisterType((*FunctionLatency)(nil), "px.stirling.dynamic_tracing.ir.shared.FunctionLatency")
}

func init() {
	proto.RegisterFile("src/stirling/source_connectors/dynamic_tracer/dynamic_tracing/ir/sharedpb/shared.proto", fileDescriptor_90e8d4eece86f82b)
}

var fileDescriptor_90e8d4eece86f82b = []byte{
	// 1185 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x8f, 0xdb, 0x54,
	0x10, 0xb6, 0x1d, 0x67, 0xd7, 0x9e, 0x64, 0xb3, 0x8f, 0xd7, 0x0a, 0x45, 0x15, 0x32, 0xdb, 0x48,
	0xa0, 0xd5, 0x22, 0x25, 0x6a, 0xb6, 0xac, 0x2a, 0x2e, 0x25, 0xc9, 0x6e, 0x13, 0xd3, 0xac, 0x1d,
	0x5e, 0x9c, 0x85, 0x72, 0xb1, 0xbc, 0xce, 0xeb, 0xd6, 0x34, 0x6b, 0x5b, 0xb6, 0x53, 0x6d, 0x2e,
	0x88, 0x03, 0xc7, 0x1e, 0xca, 0x7f, 0xc1, 0x81, 0xdf, 0x88, 0x23, 0xf7, 0x02, 0x05, 0x7a, 0x41,
	0xea, 0x81, 0x03, 0x4d, 0x2f, 0xe5, 0xd6, 0x03, 0xdc, 0xd1, 0x7b, 0x8e, 0x93, 0x2e, 0xea, 0x21,
	0xad, 0xb8, 0x7d, 0xf3, 0xde, 0xcc, 0xf7, 0xcd, 0x8c, 0xc7, 0x63, 0xc3, 0x41, 0x1c, 0xb9, 0xb5,
	0x38, 0xf1, 0xa2, 0x91, 0xe7, 0x1f, 0xd5, 0xe2, 0x60, 0x1c, 0xb9, 0xd4, 0x76, 0x03, 0xdf, 0xa7,
	0x6e, 0x12, 0x44, 0x71, 0x6d, 0x38, 0xf1, 0x9d, 0x63, 0xcf, 0xb5, 0x93, 0xc8, 0x71, 0x69, 0x74,
	0xca, 0x64, 0x01, 0x5e, 0x54, 0x8b, 0x6f, 0x38, 0x11, 0x1d, 0x86, 0x87, 0x33, 0x50, 0x0d, 0xa3,
	0x20, 0x09, 0xf0, 0x6b, 0xe1, 0x49, 0x35, 0xa3, 0xad, 0xfe, 0x27, 0xaa, 0xea, 0x45, 0xd5, 0xd4,
	0xb9, 0xf2, 0xbd, 0x04, 0x60, 0x31, 0xea, 0x30, 0xf0, 0xfc, 0x04, 0x1f, 0x80, 0x72, 0x7d, 0xec,
	0xbb, 0x89, 0x17, 0xf8, 0xe5, 0xdc, 0x86, 0xb8, 0x59, 0xa8, 0xbf, 0x55, 0x5d, 0x8a, 0xa8, 0xba,
	0x20, 0xa9, 0x5e, 0x99, 0x31, 0x90, 0x39, 0x17, 0x7e, 0x19, 0x56, 0xe2, 0xc9, 0xf1, 0x61, 0x30,
	0x2a, 0x8b, 0x1b, 0xe2, 0xa6, 0x4a, 0x66, 0x16, 0x7e, 0x07, 0xe4, 0x64, 0x12, 0xd2, 0xb2, 0xb4,
	0x21, 0x6e, 0x96, 0xea, 0x3b, 0xcf, 0xaf, 0x65, 0x4d, 0x42, 0x4a, 0x38, 0xc7, 0xb9, 0xcb, 0xa0,
	0x64, 0xca, 0x18, 0x83, 0xec, 0x3b, 0xc7, 0x74, 0xa6, 0xc6, 0x31, 0x7e, 0x15, 0x0a, 0xa1, 0x13,
	0x39, 0xc7, 0x36, 0xf3, 0x8e, 0xcb, 0xd2, 0x46, 0x6e, 0x53, 0x25, 0xc0, 0x8f, 0x18, 0x4b, 0x5c,
	0xd9, 0x02, 0x99, 0x01, 0x5c, 0x80, 0xd5, 0xae, 0xd9, 0xd6, 0x5b, 0x8d, 0x2e, 0x12, 0xb0, 0x0a,
	0xf9, 0x3d, 0xc3, 0x22, 0xd7, 0x90, 0x88, 0x01, 0x56, 0xc8, 0x9e, 0x35, 0x20, 0x06, 0x92, 0x2a,
	0x0d, 0x90, 0x07, 0x3d, 0x7d, 0x97, 0x09, 0x39, 0xb1, 0x37, 0xe4, 0x42, 0x6b, 0x84, 0x63, 0x8c,
	0x20, 0x17, 0x7a, 0x43, 0x5e, 0xd3, 0x1a, 0x61, 0x10, 0x9f, 0x81, 0x7c, 0x12, 0xdb, 0x7e, 0xcc,
	0x7b, 0x2a, 0x13, 0x39, 0x89, 0x8d, 0xb8, 0xf2, 0x3a, 0x94, 0x9a, 0x9e, 0xef, 0x44, 0x93, 0x9e,
	0x93, 0xdc, 0xe8, 0x7a, 0x71, 0x82, 0xcf, 0x42, 0x3e, 0x74, 0x92, 0x1b, 0x71, 0x59, 0xe4, 0xb9,
	0xa5, 0x46, 0x65, 0x1f, 0x14, 0x26, 0xc5, 0x3d, 0x1a, 0x90, 0x1f, 0x87, 0xde, 0x30, 0xf5, 0x28,
	0xd4, 0xdf, 0x58, 0xb2, 0x61, 0x2c, 0x9e, 0xa4, 0x91, 0x95, 0xdf, 0x65, 0x28, 0xed, 0xd2, 0x70,
	0x14, 0x4c, 0x8e, 0xa9, 0x9f, 0xf4, 0x43, 0xea, 0x62, 0x0b, 0x54, 0x26, 0x65, 0x8f, 0xbc, 0x38,
	0xe1, 0x95, 0x14, 0xea, 0x6f, 0x2e, 0xc9, 0x7c, 0xba, 0x82, 0x8e, 0x40, 0x94, 0x30, 0xab, 0xc6,
	0x00, 0x95, 0x29, 0xa6, 0xac, 0xe9, 0x30, 0xd5, 0x9e, 0x23, 0xdf, 0x8c, 0x8f, 0x71, 0x70, 0x3e,
	0x0f, 0xd6, 0xd2, 0x6b, 0x3b, 0x38, 0xfc, 0x90, 0xba, 0x49, 0x59, 0xe1, 0x9c, 0xcd, 0x25, 0x39,
	0x4f, 0xd7, 0x5c, 0xed, 0xf3, 0x53, 0x93, 0x33, 0x75, 0x04, 0x52, 0x8c, 0x9f, 0xb2, 0xb1, 0x0b,
	0x85, 0x30, 0x18, 0xda, 0x61, 0x14, 0xb8, 0x34, 0x8e, 0xcb, 0xc0, 0x85, 0xde, 0x7e, 0x31, 0xa1,
	0x5e, 0x30, 0xec, 0xa5, 0x3c, 0x1d, 0x81, 0x40, 0x38, 0xb7, 0xce, 0xb9, 0x50, 0x7c, 0x3a, 0x89,
	0x67, 0xce, 0xec, 0x65, 0x90, 0xc7, 0xd9, 0x2c, 0x3d, 0xe7, 0xe3, 0xe6, 0x81, 0xe7, 0xde, 0x07,
	0x58, 0x24, 0xc0, 0x24, 0xc2, 0x60, 0x98, 0xcd, 0x17, 0xc7, 0xf8, 0x15, 0x50, 0xdd, 0xc0, 0x4f,
	0x1c, 0xcf, 0xa7, 0x11, 0xd7, 0x51, 0xc9, 0xe2, 0x00, 0x97, 0x61, 0x35, 0xeb, 0x42, 0x8e, 0xdf,
	0x65, 0x66, 0xb3, 0x04, 0xc5, 0xc4, 0x89, 0x8e, 0x68, 0x62, 0x07, 0x3e, 0x0d, 0xae, 0x57, 0x6e,
	0x8b, 0x50, 0x3c, 0x70, 0x22, 0xcf, 0x39, 0x1c, 0x51, 0xfe, 0x1a, 0x5d, 0x85, 0x95, 0xd8, 0x75,
	0x46, 0x4e, 0x34, 0x7b, 0xbb, 0x2f, 0x2c, 0x99, 0x7d, 0x9f, 0x07, 0x31, 0x8a, 0x8e, 0x40, 0x66,
	0x14, 0xf8, 0x3c, 0x14, 0xe2, 0x24, 0x1a, 0xbb, 0x09, 0x7f, 0x7b, 0xd3, 0x5c, 0x58, 0x3f, 0xd3,
	0x43, 0xe6, 0xdc, 0x2c, 0x02, 0xb0, 0xbb, 0x59, 0x3a, 0x3f, 0x88, 0x90, 0xdb, 0x77, 0xc2, 0x67,
	0x76, 0xd5, 0x00, 0xe5, 0x26, 0x9d, 0xd8, 0xf3, 0xcd, 0x53, 0xa8, 0x6f, 0x2f, 0x99, 0xdb, 0xd3,
	0x05, 0x92, 0xd5, 0x9b, 0x74, 0xc2, 0x2b, 0x25, 0x00, 0xb7, 0x9c, 0xd1, 0x98, 0x2e, 0x72, 0x7b,
	0x41, 0x46, 0x95, 0xd3, 0x30, 0x58, 0xf9, 0x08, 0xd4, 0x56, 0xe0, 0x0f, 0x3d, 0xbe, 0xce, 0x5a,
	0x20, 0x05, 0x21, 0x2f, 0xa1, 0xb4, 0x34, 0xf1, 0x3c, 0xba, 0x6a, 0x86, 0x44, 0x0a, 0x78, 0x27,
	0x6e, 0x39, 0x51, 0xb6, 0xf8, 0x38, 0xae, 0x94, 0x41, 0x32, 0x43, 0xbc, 0x0a, 0x39, 0x43, 0xcf,
	0x96, 0xdd, 0xbb, 0x83, 0x46, 0x17, 0x89, 0x15, 0x1d, 0x56, 0x7a, 0x91, 0xe7, 0x27, 0x37, 0xf1,
	0x59, 0x90, 0x13, 0x7a, 0x92, 0x2e, 0x06, 0xd6, 0x73, 0x6e, 0xe1, 0xf2, 0xa9, 0xa7, 0xab, 0x2e,
	0x1e, 0x55, 0x73, 0x1d, 0xd6, 0xd8, 0xfc, 0x50, 0x3f, 0x9b, 0x8c, 0xf3, 0xb0, 0x9e, 0x2d, 0xe6,
	0xae, 0x93, 0x50, 0xdf, 0x9d, 0xe0, 0x12, 0x48, 0xb3, 0xa5, 0xa9, 0x12, 0xc9, 0x1b, 0x6e, 0x5d,
	0x02, 0xa5, 0xeb, 0xf8, 0x47, 0x63, 0xe7, 0x88, 0x62, 0x04, 0xc5, 0x6e, 0xc3, 0x68, 0xdb, 0x03,
	0xe3, 0xaa, 0x61, 0xbe, 0x67, 0x20, 0x01, 0xe7, 0x41, 0x6c, 0x21, 0x91, 0xa5, 0xd9, 0xea, 0xf5,
	0x90, 0xc4, 0x16, 0x71, 0xdb, 0x64, 0x3e, 0x28, 0xb7, 0xb5, 0x0f, 0x6a, 0xb3, 0x77, 0xa5, 0x43,
	0x47, 0x21, 0x8d, 0xb0, 0x02, 0x72, 0xdb, 0xd4, 0x77, 0x91, 0xc0, 0x90, 0xd5, 0xd6, 0x77, 0x91,
	0x88, 0x8b, 0xa0, 0x30, 0x64, 0xf7, 0xf4, 0x5d, 0x24, 0xe1, 0x33, 0xb0, 0xce, 0xad, 0xbe, 0xd5,
	0x20, 0x96, 0x6d, 0xe9, 0xfb, 0x7b, 0x28, 0xc7, 0xca, 0xbe, 0xca, 0xa1, 0xbc, 0xf5, 0x87, 0x04,
	0xb0, 0x18, 0x40, 0xf6, 0x29, 0x58, 0xa4, 0xa1, 0x80, 0xdc, 0x34, 0xcd, 0x2e, 0x1a, 0x62, 0x80,
	0x7c, 0xbf, 0x63, 0x12, 0x0b, 0xdd, 0x15, 0x71, 0x01, 0x56, 0x06, 0xa9, 0xf1, 0xa3, 0x88, 0x15,
	0xc8, 0xe9, 0x86, 0x85, 0x7e, 0x12, 0xb1, 0x0a, 0xf2, 0x80, 0xc1, 0x9f, 0x39, 0xec, 0x9a, 0x46,
	0x1b, 0xdd, 0x63, 0x9f, 0x90, 0xfc, 0x80, 0xe3, 0x5f, 0x44, 0xbc, 0x06, 0x0a, 0x83, 0xdc, 0xfc,
	0x55, 0xc4, 0x25, 0x50, 0x07, 0x73, 0xfb, 0x37, 0x1e, 0xa5, 0x1b, 0xd6, 0x25, 0xf4, 0x39, 0xab,
	0x37, 0xaf, 0x1b, 0xd6, 0x85, 0x1d, 0xf4, 0x45, 0x86, 0xb7, 0xeb, 0xe8, 0xcb, 0x0c, 0xef, 0x5c,
	0x44, 0x5f, 0x71, 0x3c, 0xe0, 0xfe, 0x5f, 0x4b, 0x3c, 0xa5, 0x34, 0xe0, 0x9b, 0xb9, 0xb1, 0x5d,
	0x47, 0xdf, 0xce, 0x8d, 0x9d, 0x8b, 0xe8, 0x3b, 0x89, 0x29, 0xb4, 0x3a, 0x0d, 0x82, 0xee, 0xe4,
	0x78, 0x34, 0xc7, 0x9f, 0x72, 0x7c, 0xa5, 0x6b, 0x36, 0x2c, 0xf4, 0x77, 0x8e, 0xf9, 0xef, 0x9a,
	0x83, 0x66, 0x77, 0x0f, 0xfd, 0x93, 0xc3, 0x2f, 0x41, 0xf1, 0xc0, 0x64, 0x9d, 0x34, 0x75, 0xc3,
	0xda, 0x23, 0xe8, 0x93, 0x55, 0x76, 0xdf, 0xb7, 0x88, 0x6e, 0xb4, 0xd1, 0xe3, 0x55, 0xbc, 0x0e,
	0xd0, 0xbc, 0x66, 0xed, 0xd9, 0x0d, 0x42, 0x1a, 0xd7, 0xd0, 0x5f, 0xab, 0x18, 0x41, 0xa1, 0x6f,
	0x91, 0x41, 0xcb, 0xb2, 0x9b, 0x5d, 0xb3, 0x89, 0xee, 0x29, 0xcd, 0xdb, 0xe2, 0xfd, 0x87, 0x9a,
	0xf0, 0xe0, 0xa1, 0x26, 0x3c, 0x79, 0xa8, 0x89, 0x1f, 0x4f, 0x35, 0xf1, 0xb3, 0xa9, 0x26, 0xde,
	0x9d, 0x6a, 0xe2, 0xfd, 0xa9, 0x26, 0xfe, 0x39, 0xd5, 0xc4, 0xc7, 0x53, 0x4d, 0x78, 0x32, 0xd5,
	0xc4, 0x3b, 0x8f, 0x34, 0xe1, 0xfe, 0x23, 0x4d, 0x78, 0xf0, 0x48, 0x13, 0x3e, 0x38, 0x08, 0x4f,
	0xaa, 0x43, 0x7a, 0xab, 0x16, 0x7a, 0x27, 0x1e, 0xad, 0xfd, 0x6f, 0x7f, 0x4c, 0x87, 0x2b, 0xfc,
	0x5f, 0x69, 0xfb, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x14, 0x49, 0xfe, 0x46, 0x85, 0x09, 0x00,
	0x00,
}

func (x Language) String() string {
	s, ok := Language_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x BPFHelper) String() string {
	s, ok := BPFHelper_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ScalarType) String() string {
	s, ok := ScalarType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Tracepoint_Type) String() string {
	s, ok := Tracepoint_Type_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Condition_Op) String() string {
	s, ok := Condition_Op_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Tracepoint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Tracepoint)
	if !ok {
		that2, ok := that.(Tracepoint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Function.Equal(that1.Function) {
		return false
	}
	if this.Symbol != that1.Symbol {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	return true
}
func (this *Tracepoint_Function) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Tracepoint_Function)
	if !ok {
		that2, ok := that.(Tracepoint_Function)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.ParamTypes) != len(that1.ParamTypes) {
		return false
	}
	for i := range this.ParamTypes {
		if this.ParamTypes[i] != that1.ParamTypes[i] {
			return false
		}
	}
	return true
}
func (this *UPID) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UPID)
	if !ok {
		that2, ok := that.(UPID)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Asid != that1.Asid {
		return false
	}
	if this.Pid != that1.Pid {
		return false
	}
	if this.TsNs != that1.TsNs {
		return false
	}
	return true
}
func (this *BinaryPathList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BinaryPathList)
	if !ok {
		that2, ok := that.(BinaryPathList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Paths) != len(that1.Paths) {
		return false
	}
	for i := range this.Paths {
		if this.Paths[i] != that1.Paths[i] {
			return false
		}
	}
	return true
}
func (this *UPIDList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UPIDList)
	if !ok {
		that2, ok := that.(UPIDList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Upids) != len(that1.Upids) {
		return false
	}
	for i := range this.Upids {
		if !this.Upids[i].Equal(that1.Upids[i]) {
			return false
		}
	}
	return true
}
func (this *DeploymentSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec)
	if !ok {
		that2, ok := that.(DeploymentSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.TargetOneof == nil {
		if this.TargetOneof != nil {
			return false
		}
	} else if this.TargetOneof == nil {
		return false
	} else if !this.TargetOneof.Equal(that1.TargetOneof) {
		return false
	}
	return true
}
func (this *DeploymentSpec_PathList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_PathList)
	if !ok {
		that2, ok := that.(DeploymentSpec_PathList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.PathList.Equal(that1.PathList) {
		return false
	}
	return true
}
func (this *DeploymentSpec_UpidList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_UpidList)
	if !ok {
		that2, ok := that.(DeploymentSpec_UpidList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.UpidList.Equal(that1.UpidList) {
		return false
	}
	return true
}
func (this *DeploymentSpec_SharedObject_) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_SharedObject_)
	if !ok {
		that2, ok := that.(DeploymentSpec_SharedObject_)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.SharedObject.Equal(that1.SharedObject) {
		return false
	}
	return true
}
func (this *DeploymentSpec_PodProcess_) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_PodProcess_)
	if !ok {
		that2, ok := that.(DeploymentSpec_PodProcess_)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.PodProcess.Equal(that1.PodProcess) {
		return false
	}
	return true
}
func (this *DeploymentSpec_SharedObject) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_SharedObject)
	if !ok {
		that2, ok := that.(DeploymentSpec_SharedObject)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.Upid.Equal(that1.Upid) {
		return false
	}
	return true
}
func (this *DeploymentSpec_PodProcess) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_PodProcess)
	if !ok {
		that2, ok := that.(DeploymentSpec_PodProcess)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Pods) != len(that1.Pods) {
		return false
	}
	for i := range this.Pods {
		if this.Pods[i] != that1.Pods[i] {
			return false
		}
	}
	if this.Container != that1.Container {
		return false
	}
	if this.Process != that1.Process {
		return false
	}
	return true
}
func (this *VariableType) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VariableType)
	if !ok {
		that2, ok := that.(VariableType)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.TypeOneof == nil {
		if this.TypeOneof != nil {
			return false
		}
	} else if this.TypeOneof == nil {
		return false
	} else if !this.TypeOneof.Equal(that1.TypeOneof) {
		return false
	}
	return true
}
func (this *VariableType_Scalar) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VariableType_Scalar)
	if !ok {
		that2, ok := that.(VariableType_Scalar)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Scalar != that1.Scalar {
		return false
	}
	return true
}
func (this *VariableType_StructType) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VariableType_StructType)
	if !ok {
		that2, ok := that.(VariableType_StructType)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StructType != that1.StructType {
		return false
	}
	return true
}
func (this *Map) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Map)
	if !ok {
		that2, ok := that.(Map)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.KeyType.Equal(that1.KeyType) {
		return false
	}
	if !this.ValueType.Equal(that1.ValueType) {
		return false
	}
	return true
}
func (this *Condition) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Condition)
	if !ok {
		that2, ok := that.(Condition)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Op != that1.Op {
		return false
	}
	if len(this.Vars) != len(that1.Vars) {
		return false
	}
	for i := range this.Vars {
		if this.Vars[i] != that1.Vars[i] {
			return false
		}
	}
	return true
}
func (this *Printk) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Printk)
	if !ok {
		that2, ok := that.(Printk)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.ContentOneof == nil {
		if this.ContentOneof != nil {
			return false
		}
	} else if this.ContentOneof == nil {
		return false
	} else if !this.ContentOneof.Equal(that1.ContentOneof) {
		return false
	}
	return true
}
func (this *Printk_Text) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Printk_Text)
	if !ok {
		that2, ok := that.(Printk_Text)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Text != that1.Text {
		return false
	}
	return true
}
func (this *Printk_Scalar) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Printk_Scalar)
	if !ok {
		that2, ok := that.(Printk_Scalar)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Scalar != that1.Scalar {
		return false
	}
	return true
}
func (this *FunctionLatency) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FunctionLatency)
	if !ok {
		that2, ok := that.(FunctionLatency)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	return true
}
func (this *Tracepoint) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&sharedpb.Tracepoint{")
	if this.Function != nil {
		s = append(s, "Function: "+fmt.Sprintf("%#v", this.Function)+",\n")
	}
	s = append(s, "Symbol: "+fmt.Sprintf("%#v", this.Symbol)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Tracepoint_Function) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&sharedpb.Tracepoint_Function{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ParamTypes: "+fmt.Sprintf("%#v", this.ParamTypes)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UPID) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&sharedpb.UPID{")
	s = append(s, "Asid: "+fmt.Sprintf("%#v", this.Asid)+",\n")
	s = append(s, "Pid: "+fmt.Sprintf("%#v", this.Pid)+",\n")
	s = append(s, "TsNs: "+fmt.Sprintf("%#v", this.TsNs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BinaryPathList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&sharedpb.BinaryPathList{")
	s = append(s, "Paths: "+fmt.Sprintf("%#v", this.Paths)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UPIDList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&sharedpb.UPIDList{")
	if this.Upids != nil {
		s = append(s, "Upids: "+fmt.Sprintf("%#v", this.Upids)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&sharedpb.DeploymentSpec{")
	if this.TargetOneof != nil {
		s = append(s, "TargetOneof: "+fmt.Sprintf("%#v", this.TargetOneof)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec_PathList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.DeploymentSpec_PathList{` +
		`PathList:` + fmt.Sprintf("%#v", this.PathList) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_UpidList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.DeploymentSpec_UpidList{` +
		`UpidList:` + fmt.Sprintf("%#v", this.UpidList) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_SharedObject_) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.DeploymentSpec_SharedObject_{` +
		`SharedObject:` + fmt.Sprintf("%#v", this.SharedObject) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_PodProcess_) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.DeploymentSpec_PodProcess_{` +
		`PodProcess:` + fmt.Sprintf("%#v", this.PodProcess) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_SharedObject) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&sharedpb.DeploymentSpec_SharedObject{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.Upid != nil {
		s = append(s, "Upid: "+fmt.Sprintf("%#v", this.Upid)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec_PodProcess) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&sharedpb.DeploymentSpec_PodProcess{")
	s = append(s, "Pods: "+fmt.Sprintf("%#v", this.Pods)+",\n")
	s = append(s, "Container: "+fmt.Sprintf("%#v", this.Container)+",\n")
	s = append(s, "Process: "+fmt.Sprintf("%#v", this.Process)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VariableType) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&sharedpb.VariableType{")
	if this.TypeOneof != nil {
		s = append(s, "TypeOneof: "+fmt.Sprintf("%#v", this.TypeOneof)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VariableType_Scalar) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.VariableType_Scalar{` +
		`Scalar:` + fmt.Sprintf("%#v", this.Scalar) + `}`}, ", ")
	return s
}
func (this *VariableType_StructType) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.VariableType_StructType{` +
		`StructType:` + fmt.Sprintf("%#v", this.StructType) + `}`}, ", ")
	return s
}
func (this *Map) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&sharedpb.Map{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.KeyType != nil {
		s = append(s, "KeyType: "+fmt.Sprintf("%#v", this.KeyType)+",\n")
	}
	if this.ValueType != nil {
		s = append(s, "ValueType: "+fmt.Sprintf("%#v", this.ValueType)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Condition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&sharedpb.Condition{")
	s = append(s, "Op: "+fmt.Sprintf("%#v", this.Op)+",\n")
	s = append(s, "Vars: "+fmt.Sprintf("%#v", this.Vars)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Printk) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&sharedpb.Printk{")
	if this.ContentOneof != nil {
		s = append(s, "ContentOneof: "+fmt.Sprintf("%#v", this.ContentOneof)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Printk_Text) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.Printk_Text{` +
		`Text:` + fmt.Sprintf("%#v", this.Text) + `}`}, ", ")
	return s
}
func (this *Printk_Scalar) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&sharedpb.Printk_Scalar{` +
		`Scalar:` + fmt.Sprintf("%#v", this.Scalar) + `}`}, ", ")
	return s
}
func (this *FunctionLatency) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&sharedpb.FunctionLatency{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringShared(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Tracepoint) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Tracepoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Tracepoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Function != nil {
		{
			size, err := m.Function.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != 0 {
		i = encodeVarintShared(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintShared(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Tracepoint_Function) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Tracepoint_Function) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Tracepoint_Function) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ParamTypes) > 0 {
		for iNdEx := len(m.ParamTypes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ParamTypes[iNdEx])
			copy(dAtA[i:], m.ParamTypes[iNdEx])
			i = encodeVarintShared(dAtA, i, uint64(len(m.ParamTypes[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintShared(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UPID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UPID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UPID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TsNs != 0 {
		i = encodeVarintShared(dAtA, i, uint64(m.TsNs))
		i--
		dAtA[i] = 0x18
	}
	if m.Pid != 0 {
		i = encodeVarintShared(dAtA, i, uint64(m.Pid))
		i--
		dAtA[i] = 0x10
	}
	if m.Asid != 0 {
		i = encodeVarintShared(dAtA, i, uint64(m.Asid))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BinaryPathList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BinaryPathList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BinaryPathList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Paths) > 0 {
		for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Paths[iNdEx])
			copy(dAtA[i:], m.Paths[iNdEx])
			i = encodeVarintShared(dAtA, i, uint64(len(m.Paths[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *UPIDList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UPIDList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UPIDList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Upids) > 0 {
		for iNdEx := len(m.Upids) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Upids[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintShared(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TargetOneof != nil {
		{
			size := m.TargetOneof.Size()
			i -= size
			if _, err := m.TargetOneof.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec_PathList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_PathList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PathList != nil {
		{
			size, err := m.PathList.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_UpidList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_UpidList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UpidList != nil {
		{
			size, err := m.UpidList.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_SharedObject_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_SharedObject_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SharedObject != nil {
		{
			size, err := m.SharedObject.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_PodProcess_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_PodProcess_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PodProcess != nil {
		{
			size, err := m.PodProcess.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_SharedObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec_SharedObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_SharedObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Upid != nil {
		{
			size, err := m.Upid.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintShared(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec_PodProcess) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec_PodProcess) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_PodProcess) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Process) > 0 {
		i -= len(m.Process)
		copy(dAtA[i:], m.Process)
		i = encodeVarintShared(dAtA, i, uint64(len(m.Process)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Container) > 0 {
		i -= len(m.Container)
		copy(dAtA[i:], m.Container)
		i = encodeVarintShared(dAtA, i, uint64(len(m.Container)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Pods) > 0 {
		for iNdEx := len(m.Pods) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Pods[iNdEx])
			copy(dAtA[i:], m.Pods[iNdEx])
			i = encodeVarintShared(dAtA, i, uint64(len(m.Pods[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *VariableType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VariableType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VariableType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TypeOneof != nil {
		{
			size := m.TypeOneof.Size()
			i -= size
			if _, err := m.TypeOneof.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *VariableType_Scalar) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VariableType_Scalar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintShared(dAtA, i, uint64(m.Scalar))
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *VariableType_StructType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VariableType_StructType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.StructType)
	copy(dAtA[i:], m.StructType)
	i = encodeVarintShared(dAtA, i, uint64(len(m.StructType)))
	i--
	dAtA[i] = 0x1a
	return len(dAtA) - i, nil
}
func (m *Map) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Map) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Map) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ValueType != nil {
		{
			size, err := m.ValueType.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.KeyType != nil {
		{
			size, err := m.KeyType.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintShared(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintShared(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Condition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Condition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Condition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Vars) > 0 {
		for iNdEx := len(m.Vars) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Vars[iNdEx])
			copy(dAtA[i:], m.Vars[iNdEx])
			i = encodeVarintShared(dAtA, i, uint64(len(m.Vars[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Op != 0 {
		i = encodeVarintShared(dAtA, i, uint64(m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Printk) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Printk) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Printk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ContentOneof != nil {
		{
			size := m.ContentOneof.Size()
			i -= size
			if _, err := m.ContentOneof.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *Printk_Text) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Printk_Text) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.Text)
	copy(dAtA[i:], m.Text)
	i = encodeVarintShared(dAtA, i, uint64(len(m.Text)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}
func (m *Printk_Scalar) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Printk_Scalar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.Scalar)
	copy(dAtA[i:], m.Scalar)
	i = encodeVarintShared(dAtA, i, uint64(len(m.Scalar)))
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}
func (m *FunctionLatency) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FunctionLatency) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FunctionLatency) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintShared(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintShared(dAtA []byte, offset int, v uint64) int {
	offset -= sovShared(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Tracepoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovShared(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovShared(uint64(m.Type))
	}
	if m.Function != nil {
		l = m.Function.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}

func (m *Tracepoint_Function) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovShared(uint64(l))
	}
	if len(m.ParamTypes) > 0 {
		for _, s := range m.ParamTypes {
			l = len(s)
			n += 1 + l + sovShared(uint64(l))
		}
	}
	return n
}

func (m *UPID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Asid != 0 {
		n += 1 + sovShared(uint64(m.Asid))
	}
	if m.Pid != 0 {
		n += 1 + sovShared(uint64(m.Pid))
	}
	if m.TsNs != 0 {
		n += 1 + sovShared(uint64(m.TsNs))
	}
	return n
}

func (m *BinaryPathList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Paths) > 0 {
		for _, s := range m.Paths {
			l = len(s)
			n += 1 + l + sovShared(uint64(l))
		}
	}
	return n
}

func (m *UPIDList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Upids) > 0 {
		for _, e := range m.Upids {
			l = e.Size()
			n += 1 + l + sovShared(uint64(l))
		}
	}
	return n
}

func (m *DeploymentSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TargetOneof != nil {
		n += m.TargetOneof.Size()
	}
	return n
}

func (m *DeploymentSpec_PathList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PathList != nil {
		l = m.PathList.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_UpidList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UpidList != nil {
		l = m.UpidList.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_SharedObject_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SharedObject != nil {
		l = m.SharedObject.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_PodProcess_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PodProcess != nil {
		l = m.PodProcess.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_SharedObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovShared(uint64(l))
	}
	if m.Upid != nil {
		l = m.Upid.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}

func (m *DeploymentSpec_PodProcess) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Pods) > 0 {
		for _, s := range m.Pods {
			l = len(s)
			n += 1 + l + sovShared(uint64(l))
		}
	}
	l = len(m.Container)
	if l > 0 {
		n += 1 + l + sovShared(uint64(l))
	}
	l = len(m.Process)
	if l > 0 {
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}

func (m *VariableType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TypeOneof != nil {
		n += m.TypeOneof.Size()
	}
	return n
}

func (m *VariableType_Scalar) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovShared(uint64(m.Scalar))
	return n
}
func (m *VariableType_StructType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StructType)
	n += 1 + l + sovShared(uint64(l))
	return n
}
func (m *Map) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovShared(uint64(l))
	}
	if m.KeyType != nil {
		l = m.KeyType.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	if m.ValueType != nil {
		l = m.ValueType.Size()
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}

func (m *Condition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovShared(uint64(m.Op))
	}
	if len(m.Vars) > 0 {
		for _, s := range m.Vars {
			l = len(s)
			n += 1 + l + sovShared(uint64(l))
		}
	}
	return n
}

func (m *Printk) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContentOneof != nil {
		n += m.ContentOneof.Size()
	}
	return n
}

func (m *Printk_Text) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Text)
	n += 1 + l + sovShared(uint64(l))
	return n
}
func (m *Printk_Scalar) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Scalar)
	n += 1 + l + sovShared(uint64(l))
	return n
}
func (m *FunctionLatency) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovShared(uint64(l))
	}
	return n
}

func sovShared(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozShared(x uint64) (n int) {
	return sovShared(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Tracepoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Tracepoint{`,
		`Symbol:` + fmt.Sprintf("%v", this.Symbol) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Function:` + strings.Replace(fmt.Sprintf("%v", this.Function), "Tracepoint_Function", "Tracepoint_Function", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Tracepoint_Function) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Tracepoint_Function{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ParamTypes:` + fmt.Sprintf("%v", this.ParamTypes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UPID) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UPID{`,
		`Asid:` + fmt.Sprintf("%v", this.Asid) + `,`,
		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
		`TsNs:` + fmt.Sprintf("%v", this.TsNs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BinaryPathList) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BinaryPathList{`,
		`Paths:` + fmt.Sprintf("%v", this.Paths) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UPIDList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForUpids := "[]*UPID{"
	for _, f := range this.Upids {
		repeatedStringForUpids += strings.Replace(f.String(), "UPID", "UPID", 1) + ","
	}
	repeatedStringForUpids += "}"
	s := strings.Join([]string{`&UPIDList{`,
		`Upids:` + repeatedStringForUpids + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec{`,
		`TargetOneof:` + fmt.Sprintf("%v", this.TargetOneof) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_PathList) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_PathList{`,
		`PathList:` + strings.Replace(fmt.Sprintf("%v", this.PathList), "BinaryPathList", "BinaryPathList", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_UpidList) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_UpidList{`,
		`UpidList:` + strings.Replace(fmt.Sprintf("%v", this.UpidList), "UPIDList", "UPIDList", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_SharedObject_) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_SharedObject_{`,
		`SharedObject:` + strings.Replace(fmt.Sprintf("%v", this.SharedObject), "DeploymentSpec_SharedObject", "DeploymentSpec_SharedObject", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_PodProcess_) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_PodProcess_{`,
		`PodProcess:` + strings.Replace(fmt.Sprintf("%v", this.PodProcess), "DeploymentSpec_PodProcess", "DeploymentSpec_PodProcess", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_SharedObject) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_SharedObject{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Upid:` + strings.Replace(this.Upid.String(), "UPID", "UPID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_PodProcess) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_PodProcess{`,
		`Pods:` + fmt.Sprintf("%v", this.Pods) + `,`,
		`Container:` + fmt.Sprintf("%v", this.Container) + `,`,
		`Process:` + fmt.Sprintf("%v", this.Process) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VariableType) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VariableType{`,
		`TypeOneof:` + fmt.Sprintf("%v", this.TypeOneof) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VariableType_Scalar) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VariableType_Scalar{`,
		`Scalar:` + fmt.Sprintf("%v", this.Scalar) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VariableType_StructType) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VariableType_StructType{`,
		`StructType:` + fmt.Sprintf("%v", this.StructType) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Map) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Map{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`KeyType:` + strings.Replace(this.KeyType.String(), "VariableType", "VariableType", 1) + `,`,
		`ValueType:` + strings.Replace(this.ValueType.String(), "VariableType", "VariableType", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Condition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Condition{`,
		`Op:` + fmt.Sprintf("%v", this.Op) + `,`,
		`Vars:` + fmt.Sprintf("%v", this.Vars) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Printk) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Printk{`,
		`ContentOneof:` + fmt.Sprintf("%v", this.ContentOneof) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Printk_Text) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Printk_Text{`,
		`Text:` + fmt.Sprintf("%v", this.Text) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Printk_Scalar) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Printk_Scalar{`,
		`Scalar:` + fmt.Sprintf("%v", this.Scalar) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FunctionLatency) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FunctionLatency{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringShared(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Tracepoint) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Tracepoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tracepoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Tracepoint_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Function", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Function == nil {
				m.Function = &Tracepoint_Function{}
			}
			if err := m.Function.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Tracepoint_Function) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Function: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Function: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParamTypes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParamTypes = append(m.ParamTypes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UPID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UPID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UPID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asid", wireType)
			}
			m.Asid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Asid |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
			}
			m.Pid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pid |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TsNs", wireType)
			}
			m.TsNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TsNs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BinaryPathList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BinaryPathList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BinaryPathList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UPIDList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UPIDList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UPIDList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upids", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Upids = append(m.Upids, &UPID{})
			if err := m.Upids[len(m.Upids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PathList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BinaryPathList{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_PathList{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpidList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UPIDList{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_UpidList{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharedObject", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DeploymentSpec_SharedObject{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_SharedObject_{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodProcess", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DeploymentSpec_PodProcess{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_PodProcess_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec_SharedObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SharedObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SharedObject: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upid", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Upid == nil {
				m.Upid = &UPID{}
			}
			if err := m.Upid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec_PodProcess) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodProcess: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodProcess: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pods = append(m.Pods, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Container = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Process", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Process = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VariableType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VariableType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VariableType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scalar", wireType)
			}
			var v ScalarType
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= ScalarType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TypeOneof = &VariableType_Scalar{v}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StructType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TypeOneof = &VariableType_StructType{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Map) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Map: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Map: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyType", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KeyType == nil {
				m.KeyType = &VariableType{}
			}
			if err := m.KeyType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueType", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueType == nil {
				m.ValueType = &VariableType{}
			}
			if err := m.ValueType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Condition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Condition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Condition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= Condition_Op(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vars", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Vars = append(m.Vars, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Printk) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Printk: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Printk: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContentOneof = &Printk_Text{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scalar", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContentOneof = &Printk_Scalar{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FunctionLatency) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowShared
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FunctionLatency: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FunctionLatency: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowShared
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthShared
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthShared
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipShared(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthShared
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipShared(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowShared
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowShared
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowShared
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthShared
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupShared
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthShared
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthShared        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowShared          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupShared = fmt.Errorf("proto: unexpected end of group")
)
